// 心理监测页面
Page({
  // 页面的初始数据
  data: {
    classList: [], // 班级列表
    currentClass: null, // 当前选中的班级ID
    studentList: [], // 学生列表
    testTypes: ['SAS', 'SDS'], // 测试类型列表
    currentTestType: 'SAS', // 当前选中的测试类型
    timeRange: ['最近一周', '最近一月', '最近三月', '全部'], // 时间范围选项
    currentTimeRange: '最近一月', // 当前选中的时间范围
    // 不同警告级别的颜色和文本定义
    warningLevels: {
      normal: { color: '#67C23A', text: '正常' },
      mild: { color: '#E6A23C', text: '轻度异常' },
      moderate: { color: '#F56C6C', text: '中度异常' },
      severe: { color: '#F56C6C', text: '重度异常' }
    },
    // 统计数据初始值
    statistics: {
      total: 0,
      normal: 0,
      mild: 0,
      moderate: 0,
      severe: 0
    },
    markedStudents: [], // 被标记为重点关注的学生
    showStudentDetailModal: false, // 是否显示学生详情模态框
    currentStudentDetail: null, // 当前查看详情的学生
    historyData: [] // 历史测试数据
  },

  // 页面加载时执行
  onLoad(options) {
    // 如果有传入studentId参数，直接加载指定学生
    if (options && options.studentId) {
      this.loadStudentDetail(options.studentId);
    } else {
      this.loadClassList();
      // 从本地存储加载已标记的学生
      const markedStudents = wx.getStorageSync('markedStudents') || [];
      this.setData({
        markedStudents
      });
    }
  },

  // 加载指定学生详情
  async loadStudentDetail(studentId) {
    try {
      const db = wx.cloud.database();
      // 查询学生基本信息
      const { data: student } = await db.collection('users').doc(studentId).get();
      
      // 加载学生测试结果
      const { data: testResults } = await db.collection('psychological_tests')
        .where({
          userId: studentId
        })
        .orderBy('createTime', 'desc')
        .get();
        
      // 更新页面数据，显示详情模态框
      this.setData({
        showStudentDetailModal: true,
        currentStudentDetail: {
          ...student,
          testResults: testResults || []
        }
      });
      
      // 生成历史数据图表
      this.generateHistoryChart(testResults);
    } catch (error) {
      // 错误处理
      wx.showToast({
        title: '加载学生详情失败',
        icon: 'none'
      });
    }
  },

  // 生成历史数据图表 (这里只准备数据，实际图表渲染需要引入图表组件)
  generateHistoryChart(testResults) {
    if (!testResults || testResults.length === 0) return;
    
    // 按测试类型分组
    const testTypeGroups = {};
    testResults.forEach(result => {
      if (!testTypeGroups[result.testType]) {
        testTypeGroups[result.testType] = [];
      }
      testTypeGroups[result.testType].push({
        date: new Date(result.createTime).toLocaleDateString(),
        score: result.score,
        level: result.level
      });
    });
    
    // 按日期排序
    Object.keys(testTypeGroups).forEach(type => {
      testTypeGroups[type].sort((a, b) => new Date(a.date) - new Date(b.date));
    });
    
    // 更新历史数据
    this.setData({
      historyData: testTypeGroups
    });
  },

  // 加载班级列表
  async loadClassList() {
    try {
      const db = wx.cloud.database();
      // 从数据库获取班级列表
      const { data } = await db.collection('classes').get();
      this.setData({
        classList: data
      });
    } catch (error) {
      // 错误处理
      wx.showToast({
        title: '加载班级列表失败',
        icon: 'none'
      });
    }
  },

  // 选择班级事件处理
  async onClassSelect(e) {
    const classId = e.currentTarget.dataset.id;
    this.setData({
      currentClass: classId
    });
    // 加载所选班级的学生测试结果
    await this.loadStudentTestResults(classId);
  },

  // 选择测试类型事件处理
  async onTestTypeSelect(e) {
    const testType = e.currentTarget.dataset.type;
    this.setData({
      currentTestType: testType
    });
    // 如果已选择班级，则重新加载数据
    if (this.data.currentClass) {
      await this.loadStudentTestResults(this.data.currentClass);
    }
  },

  // 选择时间范围事件处理
  async onTimeRangeSelect(e) {
    const timeRange = e.currentTarget.dataset.range;
    this.setData({
      currentTimeRange: timeRange
    });
    // 如果已选择班级，则重新加载数据
    if (this.data.currentClass) {
      await this.loadStudentTestResults(this.data.currentClass);
    }
  },

  // 加载学生测试结果
  async loadStudentTestResults(classId) {
    try {
      const db = wx.cloud.database();
      const _ = db.command;
      
      // 根据选择的时间范围计算开始日期
      const now = new Date();
      let startDate = new Date();
      switch (this.data.currentTimeRange) {
        case '最近一周':
          startDate.setDate(now.getDate() - 7);
          break;
        case '最近一月':
          startDate.setMonth(now.getMonth() - 1);
          break;
        case '最近三月':
          startDate.setMonth(now.getMonth() - 3);
          break;
        case '全部':
          startDate = new Date(0);
          break;
      }

      // 获取班级学生列表
      const { data: students } = await db.collection('users')
        .where({
          class: classId,
          role: 'student'
        })
        .get();

      // 获取符合条件的心理测试结果
      const { data: testResults } = await db.collection('psychological_tests')
        .where({
          userId: _.in(students.map(s => s._id)),
          testType: this.data.currentTestType,
          createTime: _.gte(startDate)
        })
        .orderBy('createTime', 'desc')
        .get();

      // 处理数据，为每个学生匹配其测试结果
      const studentResults = students.map(student => {
        const results = testResults.filter(r => r.userId === student._id);
        const latestResult = results[0] || null;
        return {
          ...student,
          testResults: results,
          latestResult,
          isMarked: this.data.markedStudents.includes(student._id)
        };
      });

      // 计算各级别学生人数统计
      const statistics = {
        total: studentResults.length,
        normal: 0,
        mild: 0,
        moderate: 0,
        severe: 0
      };

      // 统计各级别学生人数
      studentResults.forEach(student => {
        if (student.latestResult) {
          statistics[student.latestResult.level]++;
        }
      });

      // 更新页面数据
      this.setData({
        studentList: studentResults,
        statistics
      });
    } catch (error) {
      // 错误处理
      wx.showToast({
        title: '加载数据失败',
        icon: 'none'
      });
    }
  },

  // 查看学生详情事件处理
  onStudentDetail(e) {
    const studentId = e.currentTarget.dataset.id;
    // 从学生列表中找到对应学生
    const student = this.data.studentList.find(s => s._id === studentId);
    
    if (student) {
      // 更新当前查看的学生详情并显示模态框
      this.setData({
        showStudentDetailModal: true,
        currentStudentDetail: student
      });
      
      // 生成历史数据图表
      this.generateHistoryChart(student.testResults);
    }
  },

  // 隐藏学生详情模态框
  hideStudentDetailModal() {
    this.setData({
      showStudentDetailModal: false
    });
  },

  // 标记/取消标记关注学生
  toggleMarkStudent(e) {
    const studentId = e.currentTarget.dataset.id;
    let markedStudents = [...this.data.markedStudents];
    
    // 根据当前状态切换标记
    if (markedStudents.includes(studentId)) {
      // 取消标记
      markedStudents = markedStudents.filter(id => id !== studentId);
    } else {
      // 添加标记
      markedStudents.push(studentId);
    }
    
    // 更新标记学生数组
    this.setData({
      markedStudents
    });
    
    // 更新学生列表中的标记状态
    const studentList = this.data.studentList.map(student => {
      if (student._id === studentId) {
        return {
          ...student,
          isMarked: !student.isMarked
        };
      }
      return student;
    });
    
    // 更新页面数据
    this.setData({
      studentList
    });
    
    // 保存标记状态到本地存储
    wx.setStorageSync('markedStudents', markedStudents);
  },

  // 为学生添加备注
  addStudentRemark(e) {
    const studentId = e.currentTarget.dataset.id;
    // 显示输入备注的模态框
    wx.showModal({
      title: '添加备注',
      editable: true,
      placeholderText: '请输入备注内容',
      success: (res) => {
        // 用户点击确定且输入了内容
        if (res.confirm && res.content) {
          // 保存备注到数据库
          const db = wx.cloud.database();
          db.collection('user_remarks').add({
            data: {
              userId: studentId,
              content: res.content,
              createTime: db.serverDate()
            }
          }).then(() => {
            // 保存成功提示
            wx.showToast({
              title: '备注已添加',
              icon: 'success'
            });
          }).catch(err => {
            // 保存失败提示
            wx.showToast({
              title: '添加备注失败',
              icon: 'none'
            });
          });
        }
      }
    });
  },

  // 导出数据功能
  async exportData() {
    try {
      const db = wx.cloud.database();
      const _ = db.command;
      // 获取当前选择条件下的测试数据
      const { data } = await db.collection('psychological_tests')
        .where({
          userId: _.in(this.data.studentList.map(s => s._id)),
          testType: this.data.currentTestType
        })
        .get();

      // 处理导出数据格式
      const exportData = this.data.studentList.map(student => {
        const results = data.filter(r => r.userId === student._id);
        return {
          姓名: student.name,
          学号: student.studentId,
          班级: this.data.classList.find(c => c._id === student.class)?.name || '',
          最新测试时间: results[0]?.createTime || '',
          最新测试得分: results[0]?.score || '',
          最新测试等级: this.data.warningLevels[results[0]?.level]?.text || '',
          是否已标记: student.isMarked ? '是' : '否'
        };
      });

      // TODO: 实现导出功能
      wx.showToast({
        title: '导出成功',
        icon: 'success'
      });
    } catch (error) {
      // 错误处理
      wx.showToast({
        title: '导出失败',
        icon: 'none'
      });
    }
  }
}); 